/* eslint-disable no-prototype-builtins */
// 获取uuid
export function GetGenerateUniqueId() {
    const idPrefix = 'USER'
    const uniqueId = generateUniqueId(idPrefix)
    return uniqueId
}

// 生成uuid
export function generateUniqueId(prefix) {
    const timestamp = Date.now().toString(36)
    const randomString = Math.random().toString(36).substr(2, 5)
    const uniqueId = `${prefix}_${timestamp}_${randomString}`
    return uniqueId
}

// 工具函数：检查对象是否为空
export function hasNoOwnProperties(obj) {
    return Object.keys(obj).length === 0
}

// 工具函数：检查对象是否有对象类型的属性
export function hasObjectProperty(obj) {
    for (var key in obj) {
        if (obj.hasOwnProperty(key) && typeof obj[key] === 'object') {
            return true
        }
    }
    return false
}

/**
 * 检查是否为监控变量ID
 * @param {string} varId - 变量ID
 * @returns {boolean} 是否为监控变量
 */
function checkMonitorVarId(varId) {
    let hasVarId = false
    const monitorVars = ['M1', 'M2', 'M3', 'M4', 'M5', 'M6']
    monitorVars.forEach(element => {
        if (element === varId) {
            hasVarId = true
        }
    })
    return hasVarId
}

/**
 * 检查变量ID是否未定义或为空
 * @param {string} varId - 变量ID
 * @returns {boolean} 是否未定义或为空
 */
function checkVarIdUndefined(varId) {
    let hasVarId = false
    if (varId === undefined || varId === '') {
        hasVarId = true
    }
    return hasVarId
}

/**
 * 处理监控变量JSON
 * @param {string} name - 变量名
 * @param {string} type - 变量类型
 * @returns {string} 处理后的变量名
 */
// function processMonitorVarJSON(name, type) {
//     console.log('processMonitorVarJSON name ' + type)
//     return name
// }

/**
 * 根据类型获取默认值
 * @param {string} type - 数据类型
 * @returns {*} 默认值
 */
function getDefaultValueByType(type) {
    switch (type) {
        case 'object':
            return {}
        case 'array':
            return []
        case 'string':
            return ''
        case 'bool':
        case 'boolean':
            return false
        case 'int':
        case 'uint':
        case 'uint16':
        case 'uint32':
        case 'uint64':
        case 'int16':
        case 'int32':
        case 'int64':
            return 0
        case 'float':
        case 'double':
            return 0.0
        case 'byte':
            return 0x00
        case 'bit':
            return 0
        default:
            return ''
    }
}

/**
 * 生成模板字符串
 * @param {Object} node - 节点对象
 * @param {boolean} isPreview - 是否预览模式
 * @returns {string|*} 模板字符串或默认值
 */
function generateTemplateString(node, isPreview = false) {
    const { type, varId, devId, default: defaultValue, isDev, title } = node
    
    console.log('generateTemplateString node ' + JSON.stringify(node))
    
    // 不需要处理,直接使用默认值
    if (checkVarIdUndefined(varId) && isDev === undefined) {
        const result = defaultValue !== undefined ? defaultValue : getDefaultValueByType(type)
        return result
    }
    
    let jsonObject
    
    // 监控点变量，需要进行替换
    if (checkMonitorVarId(varId)) {
        // jsonObject = processMonitorVarJSON(defaultValue || '', type)
        // 格式改为："${timestampMs}.string"
        if (isPreview) {
            jsonObject = defaultValue !== undefined ? defaultValue : getDefaultValueByType(type)
        } else {
            jsonObject = `\${${title}}.${type}`
        }
    } else {
        console.log('generateTemplateString isDev111 ' + isDev)
        // 设备变量
        if (isDev !== undefined && isDev === true) {
            const id = devId
            if (isPreview) {
                jsonObject = defaultValue !== undefined ? defaultValue : getDefaultValueByType(type)
            } else {
                jsonObject = `\${deviceStatus}.\${${id}}.${type}`
            }
        } else {
            // 其他普通变量
            const id = varId
            if (isPreview) {
                jsonObject = defaultValue !== undefined ? defaultValue : getDefaultValueByType(type)
            } else {
                jsonObject = `\${variable}.\${${id}}.${type}`
            }
        }
    }
    return jsonObject
}

/**
 * 判断是否为叶子节点（需要转换为模板字符串的节点）
 * @param {Object} node - 节点对象
 * @returns {boolean} 是否为叶子节点
 */
function isLeafNode(node) {
    if (!node || typeof node !== 'object') {
        return false
    }
    
    // 如果有 properties，说明是容器节点，不是叶子节点
    if (node.properties) {
        return false
    }
    
    // 如果有 type 属性且不是 object 或 array，认为是叶子节点
    if (node.type && node.type !== 'object' && node.type !== 'array') {
        return true
    }
    
    // 有 varId 或 devId 且没有 properties，认为是叶子节点
    return (node.varId !== undefined || node.devId !== undefined)
}

/**
 * 转换JSON节点
 * @param {Object} node - 要转换的节点
 * @param {boolean} isPreview - 是否预览模式
 * @returns {*} 转换后的结果
 */
function transformNode(node, isPreview = false) {
    if (!node || typeof node !== 'object') {
        return node
    }
    
    // 叶子节点：转换为模板字符串
    if (isLeafNode(node)) {
        return generateTemplateString(node, isPreview)
    }
    
    // 数组类型：转换为数组格式
    if (node.type === 'array' && node.properties) {
        const result = []
        
        // 处理数组中的每个属性
        for (const key in node.properties) {
            if (node.properties.hasOwnProperty(key)) {
                const transformedItem = transformNode(node.properties[key], isPreview)
                result.push(transformedItem)
            }
        }
        
        // 如果数组为空，返回 [{}]
        return result.length > 0 ? result : [{}]
    }
    
    // 对象类型：递归处理properties
    if (node.type === 'object' && node.properties) {
        const result = {}
        
        for (const key in node.properties) {
            if (node.properties.hasOwnProperty(key)) {
                result[key] = transformNode(node.properties[key], isPreview)
            }
        }
        
        return result
    }
    
    // 其他情况，递归处理对象的每个属性
    if (typeof node === 'object' && !Array.isArray(node)) {
        const result = {}
        
        for (const key in node) {
            if (node.hasOwnProperty(key) && key !== 'type' && key !== 'title' && key !== 'name') {
                result[key] = transformNode(node[key], isPreview)
            }
        }
        
        return result
    }
    
    return node
}

/**
 * 主要转换函数：将复杂的JSON结构转换为简化的模板格式
 * @param {Object} jsonData - 原始JSON数据
 * @param {boolean} isPreview - 是否预览模式，true返回实际值，false返回模板字符串
 * @returns {Object} 转换后的JSON对象
 */
export function transformJsonSchema(jsonData, isPreview = false) {
    try {
        // 如果有root节点，提取root.properties作为根对象
        if (jsonData.root && jsonData.root.properties) {
            return transformNode(jsonData.root, isPreview)
        }
        
        // 直接转换整个对象
        return transformNode(jsonData, isPreview)
    } catch (error) {
        console.error('JSON转换失败:', error)
        return {}
    }
}

/**
 * 兼容旧版本的函数名
 * @param {Object} obj - JSON对象
 * @param {boolean} isPreview - 是否预览模式
 */
export function traverseJSON(obj, isPreview = false) {
    const transformed = transformJsonSchema(obj, isPreview)
    
    // 直接修改原对象（保持与旧版本的兼容性）
    Object.keys(obj).forEach(key => delete obj[key])
    Object.assign(obj, transformed)
}

/**
 * 兼容旧版本的函数名
 * @param {Object} obj - JSON对象
 */
export function removeExtraKeyWithObj(obj) {
    // 新版本中这个函数不再需要，转换逻辑已经整合
    console.log('removeExtraKeyWithObj: 此函数在新版本中已废弃', obj)
}
